﻿using System;
using System.Collections.Generic;
using System.Text;
using RC.ControlAcceso.BaseDatos;
using RC.ControlAcceso.BaseDatos.GestionHorariaTableAdapters;
using System.IO;
using System.Web;
using Aspose.Cells;
using Aspose;

namespace RC.ControlAcceso.ObjetosNegocio
{
    public class CA2Reportes
    {
        #region Reporte de horas Extra y Trabajadas
        public class CA2ReporteHoras
        {
            #region Atributos
            protected int _sectorId;
            protected string _sectorNombre;
            protected int _legajoId;
            protected string _nombreYApellido;
            protected int _horas;
            protected int _anual;
            protected int _mensual;
            protected int _periodo;
            #endregion

            #region Propiedades
            public int SectorId
            {
                get
                {
                    return _sectorId;
                }
                set
                {
                    _sectorId = value;
                }
            }
            public string SectorNombre
            {
                get
                {
                    return _sectorNombre;
                }
                set
                {
                    _sectorNombre = value;
                }
            }
            public int LegajoId
            {
                get
                {
                    return _legajoId;
                }
                set
                {
                    _legajoId = value;
                }
            }
            public string NombreYApellido
            {
                get
                {
                    return _nombreYApellido;
                }
                set
                {
                    _nombreYApellido = value;
                }
            }
            public int Horas
            {
                get
                {
                    return _horas;
                }
                set
                {
                    _horas = value;
                }
            }
            public int Anual
            {
                get
                {
                    return _anual;
                }
                set
                {
                    _anual = value;
                }
            }
            public int Mensual
            {
                get
                {
                    return _mensual;
                }
                set
                {
                    _mensual = value;
                }
            }
            public int Periodo
            {
                get
                {
                    return _periodo;
                }
                set
                {
                    _periodo = value;
                }
            }

            #endregion

            #region Derivados
            public string SectorYNombre
            {
                get
                {
                    return SectorId.ToString() + " - " + SectorNombre;
                }
            }
            #endregion

            #region Propiedades como string
            public string AnualString
            {
                get
                {
                    if (Anual == 0)
                        return "";
                    return Anual.ToString();
                }
            }
            public string MensualString
            {
                get
                {
                    if (Mensual == 0)
                        return "";
                    return Mensual.ToString();
                }
            }
            public string PeriodoString
            {
                get
                {
                    if (Periodo == 0)
                        return "";
                    return Periodo.ToString();
                }
            }
            #endregion
            #region Interfase DAL
            //objeto de la capa DAL
            private static CAReporteHorasTableAdapter _reporteHorasAD;
            protected static CAReporteHorasTableAdapter Adaptador
            {
                get
                {
                    if (_reporteHorasAD == null)
                        _reporteHorasAD = new CAReporteHorasTableAdapter();

                    return _reporteHorasAD;
                }
            }
            protected static CA2ReporteHoras AsignarRowAObjeto(GestionHoraria.CAReporteHorasRow pRow)
            {
                CA2ReporteHoras _reporteHoras = null;
                if (pRow != null)
                {
                    _reporteHoras = new CA2ReporteHoras();
                    _reporteHoras.SectorId = pRow.SectorId;
                    _reporteHoras.SectorNombre = pRow.Sector;
                    _reporteHoras.LegajoId = pRow.IdLegajo;
                    _reporteHoras.NombreYApellido = pRow.NombreYApellido;
                    _reporteHoras.Horas = pRow.Horas;
                }
                return _reporteHoras;
            }            
            public static CA2ReporteHorasColeccion ObtenerHorasExtra(DateTime pDesde, DateTime pHasta)
            {
                if (pDesde > pHasta)
                    throw new ArgumentException("La fecha de inicio es mayor que la final.");

                //Hago que la fecha hasta sea hasta las 23:59:59
                pHasta = pHasta.Date.AddDays(1).AddSeconds(-1);

                GestionHoraria.CAReporteHorasDataTable _dt = Adaptador.ObtenerHorasExtra(pDesde, pHasta);

                return AsignarReporteHorasTableAdapterAReporteHorasColeccion(_dt);
            }
            public static CA2ReporteHorasColeccion ObtenerHorasTrabajadas(DateTime pDesde, DateTime pHasta)
            {
                if (pDesde > pHasta)
                    throw new ArgumentException("La fecha de inicio es mayor que la final.");

                //Hago que la fecha hasta sea hasta las 23:59:59
                pHasta = pHasta.Date.AddDays(1).AddSeconds(-1);

                GestionHoraria.CAReporteHorasDataTable _dt = Adaptador.ObtenerHorasTrabajadas(pDesde, pHasta);

                return AsignarReporteHorasTableAdapterAReporteHorasColeccion(_dt);
            }
            protected static CA2ReporteHorasColeccion AsignarReporteHorasTableAdapterAReporteHorasColeccion(GestionHoraria.CAReporteHorasDataTable pDataTable)
            {
                CA2ReporteHorasColeccion _reporteHorass = new CA2ReporteHorasColeccion();
                CA2ReporteHoras _reporteHoras;

                if ((pDataTable != null)
                    && (pDataTable.Rows.Count > 0))
                {
                    foreach (GestionHoraria.CAReporteHorasRow _row in pDataTable.Rows)
                    {
                        _reporteHoras = AsignarRowAObjeto(_row);
                        if (_reporteHoras != null)
                            _reporteHorass.Add(_reporteHoras);
                    }
                }
                return _reporteHorass;
            }

            #endregion

            #region Métodos
            public CA2ReporteHoras()
            {
                AsignarValoresIniciales();
            }

            public void AsignarValoresIniciales()
            {
                SectorId = -1;
                SectorNombre = "";
                LegajoId = -1;
                NombreYApellido = "";
                Horas = 0;
                Anual = 0;
                Mensual = 0;
                Periodo = 0;
            }
            #endregion
        }
        public class CA2ReporteHorasColeccion : System.Collections.CollectionBase

        {
            public void Add(CA2ReporteHoras pReporteHoras)
            {
                this.List.Add(pReporteHoras);
            }
            public void Remove(int index)
            {
                if (index <= Count - 1 || index >= 0)
                {
                    this.List.RemoveAt(index);
                }
                else
                {
                    throw new System.ArgumentException("Fuera de rango", "original");
                }
            }            
            public CA2ReporteHoras this[int index]
            {
                get { return ((CA2ReporteHoras)(this.List[index])); }
                set { this.List[index] = value; }
            }
            #region Reporte de horas Exta y Trabajadas
            private enum ReporteEnum
            {
                HorasExtra,
                HorasTrabajadas
            }
            /// <summary>
            /// Genera el reporte de horas Extra
            /// </summary>
            /// <param name="pDesde"></param>
            /// <param name="pHasta"></param>
            /// <returns></returns>
            public CA2ReporteHorasColeccion GenerarReporteHorasExtra(DateTime pDesde, DateTime pHasta)
            {
                return GenerarReporte(pDesde, pHasta, ReporteEnum.HorasExtra);
            }
            public CA2ReporteHorasColeccion GenerarReporteHorasTrabajas(DateTime pDesde, DateTime pHasta)
            {
                return GenerarReporte(pDesde, pHasta, ReporteEnum.HorasTrabajadas);
            }

            private CA2ReporteHorasColeccion GenerarReporte(DateTime pDesde, DateTime pHasta, ReporteEnum pReporteEnum)
            {
                //Utiliza los valores de horas extra que se encuentran en el parte diario autorizado para generar el reporte.

                /////////////////////////////////
                //Genero el anual
                DateTime _primerDiaDelAno = DateTime.Parse("01/01/" + pDesde.Year.ToString());
                CA2ReporteHorasColeccion _resultado = null;
                switch (pReporteEnum)
                {
                    case ReporteEnum.HorasExtra:
                        _resultado = CA2ReporteHoras.ObtenerHorasExtra(_primerDiaDelAno, pHasta);
                        break;
                    case ReporteEnum.HorasTrabajadas:
                        _resultado = CA2ReporteHoras.ObtenerHorasTrabajadas(_primerDiaDelAno, pHasta);
                        break;
                }
                
                //Asigno las horas a Anual
                foreach (CA2ReporteHoras _reporteHoras in _resultado)
                    _reporteHoras.Anual = _reporteHoras.Horas;
                //
                /////////////////////////////

                /////////////////////////////
                //Obtengo el mensual
                DateTime _primerDiaDelMes = DateTime.Parse("01/" + pDesde.Month.ToString() + "/" + pDesde.Year.ToString());
                CA2ReporteHorasColeccion _mes = null;
                switch (pReporteEnum)
                {
                    case ReporteEnum.HorasExtra:
                        _mes = CA2ReporteHoras.ObtenerHorasExtra(_primerDiaDelMes, pHasta);
                        break;
                    case ReporteEnum.HorasTrabajadas:
                        _mes = CA2ReporteHoras.ObtenerHorasTrabajadas(_primerDiaDelMes, pHasta);
                        break;
                }
                _resultado.AsignarValores(_mes, TipoReporte.Mensual); 
                //
                ///////////////////////////////

                /////////////////////////////
                //Obtengo el periodo                
                CA2ReporteHorasColeccion _periodo = null;
                switch (pReporteEnum)
                {
                    case ReporteEnum.HorasExtra:
                        _periodo = CA2ReporteHoras.ObtenerHorasExtra(pDesde, pHasta);
                        break;
                    case ReporteEnum.HorasTrabajadas:
                        _periodo = CA2ReporteHoras.ObtenerHorasTrabajadas(pDesde, pHasta);
                        break;
                }
                _resultado.AsignarValores(_periodo, TipoReporte.Periodo); 
                //
                ///////////////////////////////
                return _resultado;
            }
            private enum TipoReporte
            {
                Mensual,
                Periodo
            }
            private void AsignarValores(CA2ReporteHorasColeccion pHorasAAgregar, TipoReporte pTipoReporte)
            {
                foreach(CA2ReporteHoras _reporteHora in this)
                    foreach (CA2ReporteHoras _reporteHoraAAgregar in pHorasAAgregar)
                    {
                        if(_reporteHora.LegajoId == _reporteHoraAAgregar.LegajoId)
                            switch (pTipoReporte)
                            {
                                case TipoReporte.Mensual:
                                    _reporteHora.Mensual = _reporteHoraAAgregar.Horas;
                                    break;
                                case TipoReporte.Periodo:
                                    _reporteHora.Periodo = _reporteHoraAAgregar.Horas;
                                    break;
                                default:
                                    throw new ArgumentException("No funciona!!");
                            }
                    }
            }

        }
            #endregion
        #endregion

        #region Reporte Liquidación Horas
        public class CA2ReporteLiquidacionHoras
        {
            #region Atributos
            protected int _Legajo;
            protected string _ConceptoDeHora;
            protected double _Cantidad;
            protected string _CodigoFaltaPayRoll;
            #endregion

            #region Propiedades
            public int Legajo
            {
                get
                {
                    return _Legajo;
                }
                set
                {
                    _Legajo = value;
                }
            }
            public string ConceptoDeHora
            {
                get
                {
                    return _ConceptoDeHora;
                }
                set
                {
                    _ConceptoDeHora = value;
                }
            }
            public double Cantidad
            {
                get
                {
                    return _Cantidad;
                }
                set
                {
                    _Cantidad = value;
                }
            }
            public string CodigoFaltaPayRoll
            {
                get
                {
                    return _CodigoFaltaPayRoll;
                }
                set
                {
                    _CodigoFaltaPayRoll = value;
                }
            }
            #endregion

            #region Propiedades derivadas
            private CA2Personal _Personal;
            public CA2Personal Personal
            {
                get
                {
                    if (_Personal == null)
                        _Personal = CA2Personal.ObtenerPersonalPorNumeroDeLegajo(Legajo);

                    return _Personal;
                }
            }
            public string PersonalNombre
            {
                get {
                    if (Personal == null)
                        return "";
                    return Personal.ApellidoYNombre; }
            }
            public string PersonalSector
            {
                get {
                    if (Personal == null)
                        return "";
                    return Personal.SectorString; }
            }
            #endregion

            #region Propiedades como string
            
            #endregion
            #region Interfase DAL
            //objeto de la capa DAL
            private static CAReporteLiquidacionHorasTableAdapter _reporteHorasAD;
            protected static CAReporteLiquidacionHorasTableAdapter Adaptador
            {
                get
                {
                    if (_reporteHorasAD == null)
                        _reporteHorasAD = new CAReporteLiquidacionHorasTableAdapter();

                    return _reporteHorasAD;
                }
            }
            protected static CA2ReporteLiquidacionHoras AsignarRowAObjeto(GestionHoraria.CAReporteLiquidacionHorasRow pRow)
            {
                CA2Reportes.CA2ReporteLiquidacionHoras _reporteLiquidacion = null;
                if (pRow != null)
                {
                    _reporteLiquidacion =  new CA2Reportes.CA2ReporteLiquidacionHoras();
                    _reporteLiquidacion.Legajo = pRow.NLegajo;
                    _reporteLiquidacion.ConceptoDeHora = pRow.ConceptoDeHora;
                    _reporteLiquidacion.Cantidad = pRow.Cantidad;
                    _reporteLiquidacion.CodigoFaltaPayRoll = CA2Parametros.ObtenerCodigoPayRoll(pRow.ConceptoDeHora);
                }
                return _reporteLiquidacion;
            }
            
            public static CA2ReporteLiquidacionHorasColeccion ObtenerLiquidacionDeHoras(DateTime pDesde, DateTime pHasta, int pEmpresaId, int pSectorId, int pLegajoDesde, int pLegajoHasta)
            {
                pDesde = pDesde.Date; //pongo hora y minutos en 00:00
                pHasta = pHasta.Date.AddDays(1).AddSeconds(-1); //ajusto la fecha fin
                                
                if (pDesde > pHasta)
                    throw new ArgumentException("La fecha de inicio es mayor que la final.");

                //Asigno el valor de la empresa segun los valores ingresados.
                int _EmpresaDesde, _EmpresaHasta;
                if(pEmpresaId > 0)
                {
                    _EmpresaDesde = pEmpresaId;
                    _EmpresaHasta = pEmpresaId;
                }
                else
                {
                    _EmpresaDesde = 0;
                    _EmpresaHasta = 99999999;
                }

                //Asigno el valor del sector segun los valores ingresados.
                int _SectorDesde, _SectorHasta;
                if(pSectorId > 0)
                {
                    _SectorDesde = pSectorId;
                    _SectorHasta = pSectorId;
                }
                else
                {
                    _SectorDesde = 0;
                    _SectorHasta = 99999999;
                }

                if ((pLegajoDesde == pLegajoHasta)
                    && (pLegajoHasta < 1))
                    pLegajoHasta = 999999999;
                
                GestionHoraria.CAReporteLiquidacionHorasDataTable _dt = Adaptador.ObtenerLiquidacionDeHoras(pDesde, pHasta, _SectorDesde, _SectorHasta, pLegajoDesde, pLegajoHasta);
                                
                return AsignarReporteHorasTableAdapterAReporteHorasColeccion(_dt);
            }
            protected static CA2ReporteLiquidacionHorasColeccion AsignarReporteHorasTableAdapterAReporteHorasColeccion(GestionHoraria.CAReporteLiquidacionHorasDataTable pDataTable)
            {
                CA2ReporteLiquidacionHorasColeccion _reporteHorass = new CA2ReporteLiquidacionHorasColeccion();
                CA2ReporteLiquidacionHoras _reporteHoras;

                if ((pDataTable != null)
                    && (pDataTable.Rows.Count > 0))
                {
                    foreach (GestionHoraria.CAReporteLiquidacionHorasRow _row in pDataTable.Rows)
                    {
                        _reporteHoras = AsignarRowAObjeto(_row);
                        if (_reporteHoras != null)
                            _reporteHorass.Add(_reporteHoras);
                    }
                }
                return _reporteHorass;
            }
            public static CA2ReporteLiquidacionHorasColeccion ObtenerLiquidacionDeHorasNoAutorizadas(DateTime pDesde, DateTime pHasta, int pSectorId, int pLegajoDesde, int pLegajoHasta)
            {
                if ((pDesde != null)
                    && (pDesde > CA2Parametros.FechaMinima))
                    pDesde = pDesde.Date;

                if ((pHasta != null)
                    && (pHasta > CA2Parametros.FechaMinima))
                    pHasta = pHasta.Date.AddDays(1).AddSeconds(-1);

                CA2ParteDiarioColeccion _partesEncontrados = CA2ParteDiario.ObtenerPartesDiariosPor(pDesde, pHasta, pLegajoDesde, "Todos", pSectorId, pLegajoHasta);
                CA2ReporteLiquidacionHorasColeccion _resultado = new CA2ReporteLiquidacionHorasColeccion();

                foreach(CA2ParteDiario _parteDiario in _partesEncontrados)
                {
                    if(_parteDiario.CantidadHorasNetas > 0)
                        _resultado.Sumar("Horas netas", _parteDiario.idLegajo, _parteDiario.CantidadHorasNetas);
                    if(_parteDiario.CantidadMinutosNocturnos > 0)
                        _resultado.Sumar("Minutos nocturnos", _parteDiario.idLegajo, _parteDiario.CantidadMinutosNocturnos);

                    if (_parteDiario.idLegajoCodigoFalta > 0)
                        _resultado.Sumar(_parteDiario.CodigoDeFaltaDetalle, _parteDiario.idLegajo, 1);

                    //_resultado[0].ConceptoDeHora
                    //_resultado[0].Legajo
                    //_resultado[0].Cantidad
                }
                return _resultado;
            }
            #endregion

            #region Métodos
            public CA2ReporteLiquidacionHoras()
            {
                AsignarValoresIniciales();
            }
            public void AsignarValoresIniciales()
            {
                Legajo = -1;
                ConceptoDeHora = "";
                Cantidad = 0;
                CodigoFaltaPayRoll = "";
            }
            #endregion
        }
        public class CA2ReporteLiquidacionHorasColeccion : System.Collections.CollectionBase
        {
            /// <summary>
            /// Los datos recibidos los suma a las cantidades en la coleccion tomando como referencia el legajo y el concepto de hora
            /// </summary>
            /// <param name="pConceptoDeHora"></param>
            /// <param name="pLegajo"></param>
            /// <param name="pCantidad"></param>
            public void Sumar(string pConceptoDeHora, int pLegajo, int pCantidad)
            {
                foreach (CA2ReporteLiquidacionHoras _elemento in this)
                {
                    if ((_elemento.ConceptoDeHora == pConceptoDeHora)
                        && (_elemento.Legajo == pLegajo))
                    {
                        _elemento.Cantidad = _elemento.Cantidad + pCantidad; // le agrego la cantidad al concepto en cuestion
                        return;
                    }
                }

                //si no lo encontro en la colección, lo tengo que dar de alta en la colección
                CA2ReporteLiquidacionHoras _liquidacion = new CA2ReporteLiquidacionHoras();
                _liquidacion.ConceptoDeHora = pConceptoDeHora;
                _liquidacion.Cantidad = pCantidad;
                _liquidacion.Legajo = pLegajo;

                this.Add(_liquidacion);
            }
            public void Add(CA2ReporteLiquidacionHoras pReporteLiqudacionHoras)
            {
                this.List.Add(pReporteLiqudacionHoras);
            }
            public void Remove(int index)
            {
                if (index <= Count - 1 || index >= 0)
                {
                    this.List.RemoveAt(index);
                }
                else
                {
                    throw new System.ArgumentException("Fuera de rango", "original");
                }
            }
            public CA2ReporteLiquidacionHoras this[int index]
            {
                get { return ((CA2ReporteLiquidacionHoras)(this.List[index])); }
                set { this.List[index] = value; }
            }
        }
        #endregion

        #region Reporte Sectores para Autorizar
        public class CA2ReporteSectores
        {
            #region Atributos
            protected int _IdSector;
            protected string _Descripcion;
            protected int _CantidadPartesNoAutorizados;
            protected int _CantidadPartesAutorizados;
            #endregion

            #region Propiedades
            public int IdSector
            {
                get
                {
                    return _IdSector;
                }
                set
                {
                    _IdSector = value;
                }
            }
            public string Descripcion
            {
                get
                {
                    return _Descripcion;
                }
                set
                {
                    _Descripcion = value;
                }
            }
            public int CantidadPartesNoAutorizados
            {
                get
                {
                    return _CantidadPartesNoAutorizados;
                }
                set
                {
                    _CantidadPartesNoAutorizados = value;
                }
            }
            public int CantidadPartesAutorizados
            {
                get
                {
                    return _CantidadPartesAutorizados;
                }
                set
                {
                    _CantidadPartesAutorizados = value;
                }
            }
            public string URLIconoAutorizado
            {
                get
                {
                    if((CantidadPartesAutorizados == 0)
                    && (CantidadPartesNoAutorizados ==0))
                        return "~/Iconos/exclamation.png"; //si los dos son cero, significa que no estan generados los partes diarios para el sector.

                    if(SectorEstaAutorizadoCompleto == true)
                        return "~/Iconos/accept.png";
                    else
                        return "~/Iconos/cross.png";
                }
            }
            #endregion

            #region Propiedades derivadas
            public bool SectorEstaAutorizadoCompleto
            {
                get
                {
                    if(CantidadPartesNoAutorizados > 0)
                        return false;
                    else
                        return true;
                }
            }

            #endregion

            #region Propiedades como string

            #endregion
            #region Interfase DAL
            //objeto de la capa DAL
            private static CAReporteSectoresTableAdapter _ReporteSectoresAD;
            protected static CAReporteSectoresTableAdapter Adaptador
            {
                get
                {
                    if (_ReporteSectoresAD == null)
                        _ReporteSectoresAD = new CAReporteSectoresTableAdapter();

                    return _ReporteSectoresAD;
                }
            }
            protected static CA2ReporteSectores AsignarRowAObjeto(GestionHoraria.CAReporteSectoresRow pRow)
            {
                CA2Reportes.CA2ReporteSectores _ReporteSectores = null;
                if (pRow != null)
                {
                    _ReporteSectores = new CA2Reportes.CA2ReporteSectores();
                    _ReporteSectores.IdSector = pRow.IdSectores;
                    _ReporteSectores.Descripcion = pRow.Descripcion;
                    _ReporteSectores.CantidadPartesNoAutorizados = pRow.CantidadDePartesNoAutorizados;
                    _ReporteSectores.CantidadPartesAutorizados = pRow.CantidadDePartesAutorizados;
                }
                return _ReporteSectores;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="pFecha"></param>
            /// <param name="pUsuarioId">Usuario del sistema actual</param>
            /// <returns></returns>
            public static CA2ReporteSectoresColeccion ObtenerSectores(DateTime pFecha, int pUsuarioId)
            {
                if (pFecha <= CA2Parametros.FechaMinima)
                    return new CA2ReporteSectoresColeccion();

                DateTime _FechaDesde = pFecha.Date; //pongo hora y minutos en 00:00
                DateTime _FechaHasta = pFecha.Date.AddDays(1).AddSeconds(-1); //ajusto la fecha fin

                GestionHoraria.CAReporteSectoresDataTable _dt = Adaptador.ObtenerSectoresParaAutorizar(_FechaDesde, _FechaHasta, pUsuarioId, DateTime.Now);

                return AsignarReporteHorasTableAdapterAReporteHorasColeccion(_dt);
            }
            protected static CA2ReporteSectoresColeccion AsignarReporteHorasTableAdapterAReporteHorasColeccion(GestionHoraria.CAReporteSectoresDataTable pDataTable)
            {
                CA2ReporteSectoresColeccion _sectores = new CA2ReporteSectoresColeccion();
                CA2ReporteSectores _sector;

                if ((pDataTable != null)
                    && (pDataTable.Rows.Count > 0))
                {
                    foreach (GestionHoraria.CAReporteSectoresRow _row in pDataTable.Rows)
                    {
                        _sector = AsignarRowAObjeto(_row);
                        if (_sectores != null)
                            _sectores.Add(_sector);
                    }
                }
                return _sectores;
            }
            #endregion

            #region Métodos
            public CA2ReporteSectores()
            {
                AsignarValoresIniciales();
            }
            public void AsignarValoresIniciales()
            {
                IdSector = -1;
                Descripcion= "";
                CantidadPartesNoAutorizados = 0;
                CantidadPartesAutorizados = 0;
            }
            #endregion
        }
        public class CA2ReporteSectoresColeccion : System.Collections.CollectionBase
        {
            public void Add(CA2ReporteSectores pSector)
            {
                this.List.Add(pSector);
            }
            public void Remove(int index)
            {
                if (index <= Count - 1 || index >= 0)
                {
                    this.List.RemoveAt(index);
                }
                else
                {
                    throw new System.ArgumentException("Fuera de rango", "original");
                }
            }
            public CA2ReporteSectores this[int index]
            {
                get { return ((CA2ReporteSectores)(this.List[index])); }
                set { this.List[index] = value; }
            }
        }
        #endregion

        #region Reporte DDJJ - OMNITRONIC
        /********************************************************************************************
 * CLASES DE ARCHIVO
 ********************************************************************************************/
        public enum Archivo_Estado
        {
            Sin_procesar, // solo para Jerarquico / Chubut y Santa Cruz
            Error,   // para los cuatro archivos
            Parcial, // para los cuatro archivos
            Completo // solo para Jerarquico / Chubut y Santa Cruz
        }
        public class Archivo
        {
            private string _Archivo_DDJJ = "";
            private string _Archivo_Jerarquico = "";
            private string _Archivo_Chubut = "";
            private string _Archivo_SantaCruz = "";

            #region Propiedades
            public string Archivo_DDJJ
            {
                get
                {
                    return _Archivo_DDJJ;
                }
                set
                {
                    _Archivo_DDJJ = value;
                }
            }
            public string Archivo_Jerarquico
            {
                get
                {
                    return _Archivo_Jerarquico;
                }
                set
                {
                    _Archivo_Jerarquico = value;
                }
            }
            public string Archivo_Chubut
            {
                get
                {
                    return _Archivo_Chubut;
                }
                set
                {
                    _Archivo_Chubut = value;
                }
            }
            public string Archivo_SantaCruz
            {
                get
                {
                    return _Archivo_SantaCruz;
                }
                set
                {
                    _Archivo_SantaCruz = value;
                }
            }
            #endregion

            #region Propiedades derivadas
            #region Estado
            public Archivo_Estado _Archivo_DDJJ_Estado
            {
                get
                {
                    if ((_Archivo_DDJJ == null)
                        || (_Archivo_DDJJ == "")
                        || (_Archivo_DDJJ.Length < 4))
                        return Archivo_Estado.Error;

                    char _estado = char.Parse(_Archivo_DDJJ.Substring(_Archivo_DDJJ.IndexOf(char.Parse("(")) + 1, 1).ToLower());
                    if (_estado == char.Parse("c"))
                        return Archivo_Estado.Completo;

                    if (_estado == char.Parse("p"))
                        return Archivo_Estado.Parcial;

                    return Archivo_Estado.Error;
                }
            }
            public Archivo_Estado _Archivo_Jerarquico_Estado
            {
                get
                {
                    if ((_Archivo_Jerarquico == null)
                        || (_Archivo_Jerarquico == "")
                        || (_Archivo_Jerarquico.Length < 4))
                        return Archivo_Estado.Sin_procesar;

                    //char _estado = _Archivo_Jerarquico[1];
                    char _estado = char.Parse(_Archivo_Jerarquico.Substring(_Archivo_Jerarquico.IndexOf(char.Parse("("))+1, 1).ToLower());
                    if (_estado == char.Parse("c"))
                        return Archivo_Estado.Completo;

                    return Archivo_Estado.Error;
                }
            }
            public Archivo_Estado _Archivo_Chubut_Estado
            {
                get
                {
                    if ((_Archivo_Chubut == null)
                        || (_Archivo_Chubut == "")
                        || (_Archivo_Chubut.Length < 4))
                        return Archivo_Estado.Sin_procesar;

                    char _estado = char.Parse(_Archivo_Chubut.Substring(_Archivo_Chubut.IndexOf(char.Parse("(")) + 1, 1).ToLower());
                    if (_estado == char.Parse("c"))
                        return Archivo_Estado.Completo;

                    return Archivo_Estado.Error;
                }
            }
            public Archivo_Estado _Archivo_SantaCruz_Estado
            {
                get
                {
                    if ((_Archivo_SantaCruz == null)
                        || (_Archivo_SantaCruz == "")
                        || (_Archivo_SantaCruz.Length < 4))
                        return Archivo_Estado.Sin_procesar;

                    char _estado = char.Parse(_Archivo_SantaCruz.Substring(_Archivo_SantaCruz.IndexOf(char.Parse("(")) + 1, 1).ToLower());
                    if (_estado == char.Parse("c"))
                        return Archivo_Estado.Completo;

                    return Archivo_Estado.Error;
                }
            }

            //Estados como string
            public string _Archivo_DDJJ_Estado_String
            {
                get
                {
                    return _Archivo_DDJJ_Estado.ToString().Replace(char.Parse("_"), char.Parse(" "));
                }
            }
            public string _Archivo_Jerarquico_Estado_String
            {
                get
                {
                    return _Archivo_Jerarquico_Estado.ToString().Replace(char.Parse("_"), char.Parse(" "));
                }
            }
            public string _Archivo_Chubut_Estado_String
            {
                get
                {
                    return _Archivo_Chubut_Estado.ToString().Replace(char.Parse("_"), char.Parse(" "));
                }
            }
            public string _Archivo_SantaCruz_Estado_String
            {
                get
                {
                    return _Archivo_SantaCruz_Estado.ToString().Replace(char.Parse("_"), char.Parse(" "));
                }
            }

            private System.Drawing.Color ColorCompleto = System.Drawing.Color.Green;
            private System.Drawing.Color ColorParcial = System.Drawing.Color.DarkGray;
            private System.Drawing.Color ColorError = System.Drawing.Color.Red;
            private System.Drawing.Color ColorSinProcesar = System.Drawing.Color.DarkGray;

            public System.Drawing.Color _Archivo_Jerarquico_Estado_Color
            {
                get
                {
                    switch (_Archivo_Jerarquico_Estado)
                    {
                        case Archivo_Estado.Completo:
                            return ColorCompleto;
                        case Archivo_Estado.Error:
                            return ColorError;
                        case Archivo_Estado.Parcial:
                            return ColorParcial;
                        case Archivo_Estado.Sin_procesar:
                            return ColorSinProcesar;
                        default:
                            return ColorError;
                    }
                }
            }
            public System.Drawing.Color _Archivo_DDJJ_Estado_Color
            {
                get
                {
                    switch (_Archivo_DDJJ_Estado)
                    {
                        case Archivo_Estado.Completo:
                            return ColorCompleto;
                        case Archivo_Estado.Error:
                            return ColorError;
                        case Archivo_Estado.Parcial:
                            return ColorParcial;
                        case Archivo_Estado.Sin_procesar:
                            return ColorSinProcesar;
                        default:
                            return ColorError;
                    }
                }
            }
            public System.Drawing.Color _Archivo_Chubut_Estado_Color
            {
                get
                {
                    switch (_Archivo_Chubut_Estado)
                    {
                        case Archivo_Estado.Completo:
                            return ColorCompleto;
                        case Archivo_Estado.Error:
                            return ColorError;
                        case Archivo_Estado.Parcial:
                            return ColorParcial;
                        case Archivo_Estado.Sin_procesar:
                            return ColorSinProcesar;
                        default:
                            return ColorError;
                    }
                }
            }
            public System.Drawing.Color _Archivo_SantaCruz_Estado_Color
            {
                get
                {
                    switch (_Archivo_SantaCruz_Estado)
                    {
                        case Archivo_Estado.Completo:
                            return ColorCompleto;
                        case Archivo_Estado.Error:
                            return ColorError;
                        case Archivo_Estado.Parcial:
                            return ColorParcial;
                        case Archivo_Estado.Sin_procesar:
                            return ColorSinProcesar;
                        default:
                            return ColorError;
                    }
                }
            }

            public string _Archivo_DDJJ_Estado_ToolTip
            {
                get
                {
                    if (_Archivo_DDJJ_Estado == Archivo_Estado.Error)
                        return "Error al procesar DDJJ, debe cargar los archivos Jerarquico, Chubut y Santa Cruz nuevamente";
                    else if (_Archivo_DDJJ_Estado == Archivo_Estado.Completo)
                        return "Descargar archivo";
                    else
                        return "";
                }
            }

            public string _Archivo_DDJJ_Enlace
            {
                get
                {
                    if (_Archivo_DDJJ_Estado == Archivo_Estado.Completo)
                    {
                        string _ruta = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority) + HttpRuntime.AppDomainAppVirtualPath; //esta linea es completa agregada
                        _ruta = _ruta + "/Reportes/DDJJ/" + _Archivo_DDJJ;
                        return _ruta;
                    }
                    else
                        return "";
                }
            }
            #endregion

            public DateTime Ano_Mes
            {
                get
                {
                    if (Nombre_Archivo_Valido(_Archivo_DDJJ) == true)
                    {
                        return ObtenerFecha(_Archivo_DDJJ).Value;
                    }
                    else if (Nombre_Archivo_Valido(_Archivo_Jerarquico) == true)
                    {
                        return ObtenerFecha(_Archivo_Jerarquico).Value;
                    }
                    else if (Nombre_Archivo_Valido(_Archivo_Chubut) == true)
                    {
                        return ObtenerFecha(_Archivo_Chubut).Value;
                    }
                    else if (Nombre_Archivo_Valido(_Archivo_SantaCruz) == true)
                    {
                        return ObtenerFecha(_Archivo_SantaCruz).Value;
                    }
                    else
                        return CA2Parametros.FechaMinima;
                }
            }
            public string Ano_Mes_String
            {
                get
                {
                    return Ano_Mes.ToString("MM-yyyy");
                }
            }
            #endregion

            #region Carga de colección
            /// <summary>
            /// Obtiene la colección de todos los archivos
            /// </summary>
            /// <returns></returns>
            public static ArchivoColeccion ObtenerTodosLosArchivos(string pRutaDDJJ)
            {
                //obtengo todos los archivos del directorio
                string[] _archivos = ObtenerArchivosDesdeDisco(pRutaDDJJ);

                //los asigno a la colección
                string _nombre_archivo;
                ArchivoColeccion _resultado = new ArchivoColeccion();
                foreach (string _archivo in _archivos)
                {
                    _nombre_archivo = System.IO.Path.GetFileName(_archivo);
                    _resultado.AgregarArchivoAColeccion(_nombre_archivo);
                }
                _resultado.OrdenarPorFecha();
                return _resultado;
            }
            private static string[] ObtenerArchivosDesdeDisco(string pRutaDDJJ)
            {

                //string[] _resultado = Directory.GetFiles(@"c:\MyDir\", "*.bmp");
                //string _ruta = Directory.GetCurrentDirectory();
                //string _ruta = Directory.GetParent(HttpContext.Current.Request.PhysicalPath).Parent.FullName; //DEBE TENER EL "\" AL FINAL
                string[] _resultado = Directory.GetFiles(pRutaDDJJ + "\\Reportes\\DDJJ\\", "*.xls");
                return _resultado;
            }
            #endregion

            #region Metodos
            /// <summary>
            /// Formato válido:
            /// YYYY-MM {DDJJ|Jerarquico|Chubut|Santa Cruz} ({Estado}) .xls
            /// Ejemplo: 2013-03-Jerarquico(C).xls
            ///          2013-03-Chubut(C).xls
            ///          2013-03-SantaCruz(C).xls
            ///          2013-03-DDJJ(P).xls
            /// Sin espacios como se muestra.
            /// </summary>
            /// <param name="pNombre"></param>
            /// <returns></returns>
            public static bool Nombre_Archivo_Valido(string pNombre)
            {
                if (pNombre.Length < 15) //es muy corto el nombre
                    return false;

                //verifico la fecha
                DateTime? _fecha = ObtenerFecha(pNombre);
                if (_fecha.HasValue == false)
                    return false;
                //string _fecha_string = "01/" + pNombre.Substring(5,2) + "/" + pNombre.Substring(0,4);
                //if (DateTime.TryParse(_fecha_string, out _fecha) == false)
                //    return false;

                //verifico el codigo al final del nombre, debe ser S E P C (sin procesar / error / parcial / completo)
                if ((pNombre.IndexOf(char.Parse("(")) < 0) //verifico que tenga el "("
                    || ((pNombre.IndexOf(char.Parse("(")) + 3) > pNombre.Length))
                    return false;

                string _estado = pNombre.Substring(pNombre.IndexOf(char.Parse("(")), 3).ToLower();
                if ((_estado != "(c)")
                    && (_estado != "(p)")
                    && (_estado != "(s)")
                    && (_estado != "(e)"))
                    return false; //no es ninguno, saldo

                // verifico la extension del archivo
                string _extension = pNombre.Substring(pNombre.IndexOf(char.Parse("."))-1, 5).ToLower();
                if (_extension != ").xls")
                    return false;

                //verifico el sector , debe ser Jerarquico, Chubut, SantaCruz, DDJJ
                string _sector = ObtenerSector(pNombre).ToLower();
                if ((_sector != "jerarquico")
                    && (_sector != "chubut")
                    && (_sector != "santacruz")
                    && (_sector != "ddjj"))
                    return false;

                return true;
            }
            /// <summary>
            /// Devuelve el primer dia del mes si es válida la conversión, ni no , devuelve nulo
            /// </summary>
            /// <param name="pNombreArchivo"></param>
            /// <returns></returns>
            public static DateTime? ObtenerFecha(string pNombreArchivo)
            {
                try
                {
                    string _fecha_string = "01/" + pNombreArchivo.Substring(5, 2) + "/" + pNombreArchivo.Substring(0, 4);
                    return DateTime.Parse(_fecha_string);
                }
                catch
                {
                    return null;
                }

            }
            public static string ObtenerSector(string pNombreArchivo)
            {
                //verifico el sector , debe ser Jerarquico, Chubut, SantaCruz, DDJJ
                return pNombreArchivo.Substring(8, pNombreArchivo.IndexOf(char.Parse("(")) - 8);
            }
            #endregion
        }
        public class ArchivoColeccion : System.Collections.CollectionBase
        {
            public void Add(Archivo pArchivo)
            {
                this.List.Add(pArchivo);
            }
            public void Remove(int index)
            {
                if (index <= Count - 1 || index >= 0)
                {
                    this.List.RemoveAt(index);
                }
                else
                {
                    throw new System.ArgumentException("Fuera de rango", "original");
                }
            }
            public Archivo this[int index]
            {
                get { return ((Archivo)(this.List[index])); }
                set { this.List[index] = value; }
            }
            /// <summary>
            /// Agrega el archivo al objeto correspondiente, si no existe el objeto correspondiente , lo crea.
            /// Para que corresponda, deben coincidir los cuatro archivos en el mes y año.
            /// </summary>
            /// <param name="pArchivo"></param>
            public void AgregarArchivoAColeccion(string pArchivo)
            {
                //verifico que else formato sea correcto
                if (Archivo.Nombre_Archivo_Valido(pArchivo) == false)
                    return;

                // lo busco y si encuentro el correspondiente, lo muestro
                string _sector = Archivo.ObtenerSector(pArchivo);

                DateTime? _AnoMes = Archivo.ObtenerFecha(pArchivo);
                if (_AnoMes.HasValue == false)
                    return;

                foreach (Archivo _archivo in this)
                {
                    //verifico que sea del mismo mes
                    if (_archivo.Ano_Mes == _AnoMes)
                    {
                        //segun el sector verifico 
                        if (_sector.ToLower() == "jerarquico")
                        {
                            _archivo.Archivo_Jerarquico = pArchivo;
                            return;
                        }

                        if (_sector.ToLower() == "chubut")
                        {
                            _archivo.Archivo_Chubut = pArchivo;
                            return;
                        }

                        if (_sector.ToLower() == "santacruz")
                        {
                            _archivo.Archivo_SantaCruz = pArchivo;
                            return;
                        }

                        if (_sector.ToLower() == "ddjj")
                        {
                            _archivo.Archivo_DDJJ = pArchivo;
                            return;
                        }
                    }
                }

                //el archivo no está en la colección, tengo que crear un nuevo objeto Archivo y agregarlo
                Archivo _Archivo_Nuevo = new Archivo();
                //segun el sector verifico 
                if (_sector.ToLower() == "jerarquico")
                    _Archivo_Nuevo.Archivo_Jerarquico = pArchivo;

                if (_sector.ToLower() == "chubut")
                    _Archivo_Nuevo.Archivo_Chubut = pArchivo;

                if (_sector.ToLower() == "santacruz")
                    _Archivo_Nuevo.Archivo_SantaCruz = pArchivo;

                if (_sector.ToLower() == "ddjj")
                    _Archivo_Nuevo.Archivo_DDJJ = pArchivo;

                this.Add(_Archivo_Nuevo);

            }

            #region Ordenamiento de colecciones
            public void OrdenarPorFecha()
            {

                System.Collections.IComparer sorter = new OrdenarPorFechaHelper();

                InnerList.Sort(sorter);

            }
            private class OrdenarPorFechaHelper : System.Collections.IComparer
            {

                public int Compare(object x, object y)
                {

                    Archivo p1 = (Archivo)x;

                    Archivo p2 = (Archivo)y;

                    if (p1.Ano_Mes < p2.Ano_Mes)
                        return 1;

                    if (p1.Ano_Mes > p2.Ano_Mes)
                        return -1;

                    return 0;
                }

            }
            #endregion
        }
        #endregion
    }
}

    

